﻿// #include "guild_service_query.h"

// #include "AnnounceMsg_struct.h"
// #include "AnnounceData_struct.h"
// #include "GuildModuleBrief_struct.h"
// #include "GuildMember_struct.h"
// #include "GuildModuleMembers_struct.h"

// #include "guild/guild_loader.hpp"
// #include "guild/guild_saver.hpp"
// // #include "guild/module/guild_module_loader.hpp"
// #include "guild/guild_redis_key_def.h"

// namespace guild_service {
// const Guild *GuildServiceQuery::GetGuild(const guild_id_type guild_id) const {
//   auto iter = guilds_.find(guild_id);
//   if (iter == guilds_.end()) {
//     return nullptr;
//   }

//   return &(iter->second);
// }

// const Guild *GuildServiceQuery::GetGuildByRole(const role_uuid_type role_uuid) {
//   guild_id_type guild_id = GetGuildIdByRole(role_uuid);
//   if (guild_id == kInvalidGuildId) {
//     return nullptr;
//   }
//   return GetGuild(guild_id);
// }

// guild_id_type GuildServiceQuery::GetGuildIdByRole(
//     const role_uuid_type role_uuid) {
//   // const auto get_guild_id_func =
//   //     [this](const role_uuid_type role_uuid) -> guild_id_type {
//   //   auto iter = role_to_guild_id_.find(role_uuid);
//   //   if (iter == role_to_guild_id_.end()) {
//   //     return kInvalidGuildId;
//   //   }
//   //   return iter->second;
//   // };

//   // guild_id_type guild_id = get_guild_id_func(role_uuid);
//   // if (guild_id != kInvalidGuildId) {
//   //   return guild_id;
//   // }

//   guild_id_type guild_id = kInvalidGuildId;
//   if (!GetGuildIdByRoleFromRedis(role_uuid, guild_id)) {
//     return kInvalidGuildId;
//   }

//   return guild_id;

//   // if (guild_id != kInvalidGuildId) {  // 读取redis数据 加入缓存
//   //   if (!AddGuildRole(guild_id, role_uuid)) {
//   //     LOG_DEBUG("重复添加角色到公会id的映射 角色唯一id:%llu 公会id:%llu",
//   //               role_uuid, guild_id);
//   //   }
//   //   return guild_id;
//   // }

//   // // 协程返回 数据可能已经发生改变 需要重新获取一次
//   // return get_guild_id_func(role_uuid);
// }

// bool GuildServiceQuery::GetGuildIdByRoleFromRedis(
//     const role_uuid_type role_uuid, guild_id_type &guild_id) const {
//   return detail::LoadGuildIdByRole(kGuildServiceQueryName, role_uuid, guild_id);
// }

// bool GuildServiceQuery::AddGuild(const Guild &guild) {
//   // LOG_DEBUG("添加公会 公会id:%llu", guild.id);

//   return guilds_.emplace(guild.id, guild).second;
// }

// bool GuildServiceQuery::RemoveGuild(const guild_id_type guild_id) {
//   LOG_DEBUG("移除公会 公会id:%llu", guild_id);

//   // TODO mutex

//   return guilds_.erase(guild_id) > 0;
// }

// bool GuildServiceQuery::AddGuildRole(const guild_id_type guild_id,
//                                      const role_uuid_type role_uuid) {
//   LOG_DEBUG("添加公会角色 角色唯一id:%llu 公会id:%llu", role_uuid, guild_id);

//   return role_to_guild_id_.emplace(role_uuid, guild_id).second;
// }

// bool GuildServiceQuery::LoadGuildAsync() {
//   if (!LoadGuildIdAsync()) {
//     LOG_FAIL("异步加载公会id失败");
//     return false;
//   }

//   if (!LoadGuildModuleAsync()) {
//     LOG_FAIL("异步加载公会模块失败");
//     return false;
//   }

//   return true;
// }


// void splitBy(const std::string &src, char delim,
//              std::vector<std::string> &result) {
//   result.clear();
//   if (src.empty()) {
//     return;
//   }
//   std::string item;
//   for (auto &c : src) {
//     if (c != delim) {
//       item.push_back(c);
//     } else {
//       item.push_back(delim);
//       result.push_back(std::move(item));
//     }
//   }
//   if (!item.empty()) {
//     result.push_back(std::move(item));
//   }
// }

// static std::vector<std::string> split_str;

// bool GuildServiceQuery::LoadGuildIdAsync() {
//   return guild_service::detail::LoadAllGuildIdAsync(
//       kGuildServiceQueryName,
//       [](const std::vector<std::string> &guild_str_list) {
//         for (const auto &str : guild_str_list) {
//           split_str.clear();

//           // UtilSingleton()->splitBy(str, ':', split_str);
//           splitBy(str, ':', split_str);
//           if (split_str.size() >= 2) {
//             // LOG_DEBUG("获取公会id 键:%s", str.c_str());
//             guild_id_type guild_id = std::stoull(split_str[1]);
//             Guild guild = GuildServiceQuery::NewGuild(guild_id);
//             GuildServiceQuerySingleton->AddGuild(guild);
//           } else {
//             LOG_FAIL("字符串分割失败 键:%s", str.c_str());
//           }
//         }
//       });
// }

// bool GuildServiceQuery::LoadGuildModuleAsync() {
//   ForeachGuild([](const Guild &guild) {
//     detail::GetGuildModuleAsync<GuildBrief>(kGuildServiceQueryName, guild,
//                                             kGuildModuleBriefName);
//     detail::GetGuildModuleAsync<GuildMembers>(kGuildServiceQueryName, guild,
//                                               kGuildModuleMembersName);
//   });
//   return true;
// }

// bool GuildServiceQuery::IncrGuildLastId(guild_id_type &guild_id) {
//   return detail::IncrGuildGeneralId(kGuildServiceQueryName,
//                                     detail::kLoadGuildLastIdKey, guild_id);
// }

// bool GuildServiceQuery::SaveGuildRoleToRedis(const std::string &op,
//                                              const role_uuid_type role_uuid,
//                                              const guild_id_type guild_id) {
//   return detail::SaveGuildIdByRole(kGuildServiceQueryName, op, role_uuid,
//                                    guild_id);
// }

// bool GuildServiceQuery::SaveLastGuildIdToRedis(const guild_id_type guild_id) {
//   return detail::SaveLastGuildId(kGuildServiceQueryName, guild_id);
// }

// bool GuildServiceQuery::RemoveGuildRole(const guild_id_type guild_id,
//                                         const role_uuid_type role_uuid) {
//   LOG_DEBUG("公会id:%llu 角色唯一id:%llu 移除公会角色", guild_id, role_uuid);

//   return role_to_guild_id_.erase(role_uuid) > 0;
// }

// Guild GuildServiceQuery::NewGuild(const guild_id_type guild_id /* = 0ull*/) {
//   Guild guild;

//   if (guild_id != 0) {
//     guild.id = guild_id;
//   } else {
//     if (!GuildServiceQuery::IncrGuildLastId(guild.id)) {
//       guild.id = kInvalidGuildId;
//       return guild;
//     }
//   }

//   guild.pool_index = guild_service::detail::NewPoolIndex();

//   return guild;
// }

// bool GuildServiceQuery::InSameGuild(const role_uuid_type role_uuid1,
//                                     const role_uuid_type role_uuid2) {
//   guild_id_type guild_id1 = GetGuildIdByRole(role_uuid1);
//   guild_id_type guild_id2 = GetGuildIdByRole(role_uuid2);
//   if (guild_id1 == kInvalidGuildId || guild_id2 == kInvalidGuildId) {
//     return false;
//   }

//   if (guild_id1 == kInvalidGuildId || guild_id2 == kInvalidGuildId) {
//     return false;
//   }

//   return guild_id1 == guild_id2;
// }

// bool GuildServiceQuery::IsValidGuild(const Guild &guild) {
//   return guild.id != kInvalidGuildId && guild.pool_index != kInvalidPoolIndex;
// }

// bool GuildServiceQuery::HasGuild(const role_uuid_type role_uuid) const {
//   return role_to_guild_id_.count(role_uuid) > 0;
// }

// bool GuildServiceQuery::IsGuildNameExisted(const std::string &name) const {
//   for (auto it : guilds_) {
//     const auto &guild = it.second;
//     const auto *guild_brief_ptr = detail::GetGuildModule<GuildBrief>(
//         kGuildServiceQueryName, guild, kGuildModuleBriefName,
//         GetModulePriority::GET_MODULE_PRI_USE_CACHE);
//     if (guild_brief_ptr && guild_brief_ptr->name == name) {
//       return true;
//     }
//   }

//   return false;
// }

// void GuildServiceQuery::ForeachGuild(const ForeachGuildCallbackType &callback) {
//   if (!callback) {
//     return;
//   }

//   for (const auto &it : guilds_) {
//     callback(it.second);
//   }
// }

// }  // namespace guild_service